home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / gasmania.swf / scripts / DefineSprite_680 / frame_3 / DoAction.as
Encoding:
Text File  |  2007-10-01  |  84.4 KB  |  1,762 lines

  1. var ┬º\x01┬º = 520;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 520)
  6.    {
  7.       set("\x01",eval("\x01") - 487);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 988)
  12.    {
  13.       set("\x01",eval("\x01") - 25);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 433)
  17.    {
  18.       set("\x01",eval("\x01") - 235);
  19.       loop3:
  20.       while(true)
  21.       {
  22.          set(┬º┬ºpop(),eval(┬º┬ºpop()) + 38);
  23.          loop4:
  24.          while(true)
  25.          {
  26.             while(true)
  27.             {
  28.                if(eval("\x01") == 992)
  29.                {
  30.                   set("\x01",eval("\x01") - 150);
  31.                   ┬º┬ºpush(true);
  32.                }
  33.                else
  34.                {
  35.                   if(eval("\x01") == 585)
  36.                   {
  37.                      break loop4;
  38.                   }
  39.                   if(eval("\x01") == 842)
  40.                   {
  41.                      set("\x01",eval("\x01") - 729);
  42.                      if(┬º┬ºpop())
  43.                      {
  44.                         set("\x01",eval("\x01") + 62);
  45.                      }
  46.                   }
  47.                   else
  48.                   {
  49.                      if(eval("\x01") == 113)
  50.                      {
  51.                         set("\x01",eval("\x01") + 62);
  52.                         break loop0;
  53.                      }
  54.                      if(eval("\x01") == 623)
  55.                      {
  56.                         set("\x01",eval("\x01") + 57);
  57.                      }
  58.                      else if(eval("\x01") == 645)
  59.                      {
  60.                         set("\x01",eval("\x01") + 308);
  61.                      }
  62.                      else if(eval("\x01") == 288)
  63.                      {
  64.                         set("\x01",eval("\x01") + 86);
  65.                         if(┬º┬ºpop())
  66.                         {
  67.                            set("\x01",eval("\x01") + 399);
  68.                         }
  69.                      }
  70.                      else if(eval("\x01") == 15)
  71.                      {
  72.                         set("\x01",eval("\x01") + 273);
  73.                         ┬º┬ºpush(true);
  74.                      }
  75.                      else if(eval("\x01") == 569)
  76.                      {
  77.                         set("\x01",eval("\x01") + 111);
  78.                      }
  79.                      else
  80.                      {
  81.                         if(eval("\x01") == 374)
  82.                         {
  83.                            set("\x01",eval("\x01") + 399);
  84.                            break loop0;
  85.                         }
  86.                         if(eval("\x01") == 773)
  87.                         {
  88.                            set("\x01",eval("\x01") + 180);
  89.                         }
  90.                         else if(eval("\x01") == 175)
  91.                         {
  92.                            set("\x01",eval("\x01") - 160);
  93.                         }
  94.                         else
  95.                         {
  96.                            if(eval("\x01") == 166)
  97.                            {
  98.                               break;
  99.                            }
  100.                            if(eval("\x01") == 324)
  101.                            {
  102.                               set("\x01",eval("\x01") - 309);
  103.                            }
  104.                            else
  105.                            {
  106.                               if(eval("\x01") != 953)
  107.                               {
  108.                                  if(eval("\x01") == 680)
  109.                                  {
  110.                                     set("\x01",eval("\x01") - 382);
  111.                                     this._x = -56.8 + _root.PiaoSound.getVolume() * 1.8;
  112.                                     break loop0;
  113.                                  }
  114.                                  if(eval("\x01") == 298)
  115.                                  {
  116.                                     set("\x01",eval("\x01") - 298);
  117.                                  }
  118.                                  break loop0;
  119.                               }
  120.                               set("\x01",eval("\x01") - 787);
  121.                               ┬º┬ºpush(true);
  122.                            }
  123.                         }
  124.                      }
  125.                   }
  126.                }
  127.             }
  128.             set("\x01",eval("\x01") + 419);
  129.             if(!┬º┬ºpop())
  130.             {
  131.                continue;
  132.             }
  133.             continue loop3;
  134.          }
  135.          set("\x01",eval("\x01") + 38);
  136.          loop6:
  137.          while(true)
  138.          {
  139.             if(!┬º┬ºpop())
  140.             {
  141.                set("\x01",eval("\x01") + 610);
  142.             }
  143.             else if(eval("\x01") == 373)
  144.             {
  145.                set("\x01",eval("\x01") + 251);
  146.             }
  147.             else if(eval("\x01") == 991)
  148.             {
  149.                set("\x01",eval("\x01") - 568);
  150.             }
  151.             else if(eval("\x01") == 493)
  152.             {
  153.                set("\x01",eval("\x01") + 312);
  154.             }
  155.             else if(eval("\x01") == 909)
  156.             {
  157.                set("\x01",eval("\x01") - 833);
  158.                if(┬º┬ºpop())
  159.                {
  160.                   set("\x01",eval("\x01") + 374);
  161.                }
  162.             }
  163.             else if(eval("\x01") == 262)
  164.             {
  165.                set("\x01",eval("\x01") + 410);
  166.                ┬º┬ºpush(true);
  167.             }
  168.             else
  169.             {
  170.                if(eval("\x01") == 220)
  171.                {
  172.                   set("\x01",eval("\x01") + 701);
  173.                   ┬º┬ºpush(Number(┬º┬ºpop()));
  174.                   break loop0;
  175.                }
  176.                if(eval("\x01") == 672)
  177.                {
  178.                   set("\x01",eval("\x01") - 311);
  179.                   if(┬º┬ºpop())
  180.                   {
  181.                      set("\x01",eval("\x01") - 166);
  182.                   }
  183.                }
  184.                else
  185.                {
  186.                   if(eval("\x01") == 361)
  187.                   {
  188.                      set("\x01",eval("\x01") - 166);
  189.                      break loop0;
  190.                   }
  191.                   if(eval("\x01") == 542)
  192.                   {
  193.                      set("\x01",eval("\x01") + 419);
  194.                      eval("{invalid_utf8=238}{invalid_utf8=237}{invalid_utf8=65}_")["{invalid_utf8=231}\b\r{invalid_utf8=184}{invalid_utf8=144}{invalid_utf8=190}C{invalid_utf8=173}"]("\x15{invalid_utf8=130}h","\x15{invalid_utf8=130}h",eval("{invalid_utf8=238}{invalid_utf8=237}{invalid_utf8=65}_")["{invalid_utf8=178}E\x0b{invalid_utf8=204}"]());
  195.                      break loop0;
  196.                   }
  197.                   if(eval("\x01") == 702)
  198.                   {
  199.                      set("\x01",eval("\x01") - 482);
  200.                      if(┬º┬ºpop())
  201.                      {
  202.                         set("\x01",eval("\x01") + 701);
  203.                      }
  204.                   }
  205.                   else
  206.                   {
  207.                      if(eval("\x01") != 921)
  208.                      {
  209.                         if(eval("\x01") == 961)
  210.                         {
  211.                            set("\x01",eval("\x01") - 961);
  212.                         }
  213.                         break loop0;
  214.                      }
  215.                      set("\x01",eval("\x01") - 498);
  216.                   }
  217.                }
  218.             }
  219.             while(true)
  220.             {
  221.                if(eval("\x01") == 212)
  222.                {
  223.                   set("\x01",eval("\x01") + 716);
  224.                   ┬º┬ºpush(true);
  225.                   continue;
  226.                }
  227.                if(eval("\x01") == 126)
  228.                {
  229.                   set("\x01",eval("\x01") + 136);
  230.                   continue;
  231.                }
  232.                if(eval("\x01") == 928)
  233.                {
  234.                   set("\x01",eval("\x01") - 49);
  235.                   if(┬º┬ºpop())
  236.                   {
  237.                      set("\x01",eval("\x01") - 118);
  238.                   }
  239.                   continue;
  240.                }
  241.                if(eval("\x01") == 353)
  242.                {
  243.                   set("\x01",eval("\x01") - 38);
  244.                   continue;
  245.                }
  246.                if(eval("\x01") == 805)
  247.                {
  248.                   set("\x01",eval("\x01") - 103);
  249.                   ┬º┬ºpush(true);
  250.                   continue;
  251.                }
  252.                if(eval("\x01") == 738)
  253.                {
  254.                   set("\x01",eval("\x01") - 250);
  255.                   addr610:
  256.                   if(┬º┬ºpop())
  257.                   {
  258.                      if(eval("\x01") == 296)
  259.                      {
  260.                         set("\x01",eval("\x01") + 17);
  261.                         addr148:
  262.                         if(eval("\x01") == 522)
  263.                         {
  264.                            set("\x01",eval("\x01") - 214);
  265.                            ┬º┬ºgoto(addr148);
  266.                            ┬º┬ºpush(true);
  267.                         }
  268.                         if(eval("\x01") == 308)
  269.                         {
  270.                            set("\x01",eval("\x01") - 22);
  271.                            if(!┬º┬ºpop())
  272.                            {
  273.                               addr185:
  274.                               ┬º┬ºgoto(addr148);
  275.                            }
  276.                            set("\x01",eval("\x01") - 96);
  277.                            ┬º┬ºgoto(addr185);
  278.                         }
  279.                         if(eval("\x01") == 658)
  280.                         {
  281.                            set("\x01",eval("\x01") - 241);
  282.                            ┬º┬ºgoto(addr148);
  283.                            ┬º┬ºpush(true);
  284.                         }
  285.                         if(eval("\x01") == 812)
  286.                         {
  287.                            set("\x01",eval("\x01") - 6);
  288.                            ┬º┬ºgoto(addr148);
  289.                         }
  290.                         if(eval("\x01") == 417)
  291.                         {
  292.                            set("\x01",eval("\x01") + 283);
  293.                            if(!┬º┬ºpop())
  294.                            {
  295.                               addr234:
  296.                               ┬º┬ºgoto(addr148);
  297.                            }
  298.                            set("\x01",eval("\x01") + 30);
  299.                            ┬º┬ºgoto(addr234);
  300.                         }
  301.                         if(eval("\x01") != 283)
  302.                         {
  303.                            if(eval("\x01") == 162)
  304.                            {
  305.                               set("\x01",eval("\x01") + 746);
  306.                               ┬º┬ºgoto(addr148);
  307.                            }
  308.                            if(eval("\x01") == 317)
  309.                            {
  310.                               set("\x01",eval("\x01") + 227);
  311.                               if(!┬º┬ºpop())
  312.                               {
  313.                                  addr282:
  314.                                  ┬º┬ºgoto(addr148);
  315.                               }
  316.                               set("\x01",eval("\x01") - 467);
  317.                               ┬º┬ºgoto(addr282);
  318.                            }
  319.                            if(eval("\x01") == 267)
  320.                            {
  321.                               set("\x01",eval("\x01") + 641);
  322.                               ┬º┬ºgoto(addr148);
  323.                            }
  324.                            if(eval("\x01") == 543)
  325.                            {
  326.                               set("\x01",eval("\x01") - 95);
  327.                               ┬º┬ºgoto(addr148);
  328.                            }
  329.                            if(eval("\x01") == 864)
  330.                            {
  331.                               set("\x01",eval("\x01") - 321);
  332.                               ┬º┬ºgoto(addr148);
  333.                            }
  334.                            if(eval("\x01") == 655)
  335.                            {
  336.                               set("\x01",eval("\x01") - 162);
  337.                               ┬º┬ºgoto(addr148);
  338.                            }
  339.                            if(eval("\x01") == 732)
  340.                            {
  341.                               set("\x01",eval("\x01") - 449);
  342.                               if(!┬º┬ºpop())
  343.                               {
  344.                                  addr358:
  345.                                  ┬º┬ºgoto(addr148);
  346.                               }
  347.                               set("\x01",eval("\x01") + 32);
  348.                               ┬º┬ºgoto(addr358);
  349.                            }
  350.                            if(eval("\x01") == 936)
  351.                            {
  352.                               set("\x01",eval("\x01") - 58);
  353.                               if(!┬º┬ºpop())
  354.                               {
  355.                                  addr379:
  356.                                  ┬º┬ºgoto(addr148);
  357.                               }
  358.                               set("\x01",eval("\x01") - 582);
  359.                               ┬º┬ºgoto(addr379);
  360.                            }
  361.                            if(eval("\x01") == 920)
  362.                            {
  363.                               set("\x01",eval("\x01") - 863);
  364.                               ┬º┬ºgoto(addr148);
  365.                            }
  366.                            if(eval("\x01") == 23)
  367.                            {
  368.                               set("\x01",eval("\x01") + 552);
  369.                               if(!┬º┬ºpop())
  370.                               {
  371.                                  addr413:
  372.                                  ┬º┬ºgoto(addr148);
  373.                               }
  374.                               set("\x01",eval("\x01") - 308);
  375.                               ┬º┬ºgoto(addr413);
  376.                            }
  377.                            if(eval("\x01") == 204)
  378.                            {
  379.                               set("\x01",eval("\x01") + 770);
  380.                               if(!┬º┬ºpop())
  381.                               {
  382.                                  addr434:
  383.                                  ┬º┬ºgoto(addr148);
  384.                               }
  385.                               set("\x01",eval("\x01") - 404);
  386.                               ┬º┬ºgoto(addr434);
  387.                            }
  388.                            if(eval("\x01") != 328)
  389.                            {
  390.                               if(eval("\x01") == 720)
  391.                               {
  392.                                  set("\x01",eval("\x01") - 19);
  393.                                  ┬º┬ºgoto(addr148);
  394.                               }
  395.                               if(eval("\x01") == 806)
  396.                               {
  397.                                  set("\x01",eval("\x01") - 489);
  398.                                  ┬º┬ºgoto(addr148);
  399.                                  ┬º┬ºpush(true);
  400.                               }
  401.                               if(eval("\x01") != 575)
  402.                               {
  403.                                  if(eval("\x01") == 730)
  404.                                  {
  405.                                     set("\x01",eval("\x01") - 51);
  406.                                     ┬º┬ºgoto(addr148);
  407.                                  }
  408.                                  if(eval("\x01") == 57)
  409.                                  {
  410.                                     set("\x01",eval("\x01") - 34);
  411.                                     ┬º┬ºgoto(addr148);
  412.                                     ┬º┬ºpush(true);
  413.                                  }
  414.                                  if(eval("\x01") != 878)
  415.                                  {
  416.                                     if(eval("\x01") == 781)
  417.                                     {
  418.                                        set("\x01",eval("\x01") - 724);
  419.                                        ┬º┬ºgoto(addr148);
  420.                                     }
  421.                                     if(eval("\x01") == 908)
  422.                                     {
  423.                                        set("\x01",eval("\x01") - 176);
  424.                                        ┬º┬ºgoto(addr148);
  425.                                        ┬º┬ºpush(true);
  426.                                     }
  427.                                     if(eval("\x01") == 823)
  428.                                     {
  429.                                        set("\x01",eval("\x01") - 146);
  430.                                        if(!┬º┬ºpop())
  431.                                        {
  432.                                           addr583:
  433.                                           ┬º┬ºgoto(addr148);
  434.                                        }
  435.                                        set("\x01",eval("\x01") + 112);
  436.                                        ┬º┬ºgoto(addr583);
  437.                                     }
  438.                                     if(eval("\x01") == 27)
  439.                                     {
  440.                                        set("\x01",eval("\x01") + 301);
  441.                                        if(!┬º┬ºpop())
  442.                                        {
  443.                                           addr604:
  444.                                           ┬º┬ºgoto(addr148);
  445.                                        }
  446.                                        set("\x01",eval("\x01") + 592);
  447.                                        ┬º┬ºgoto(addr604);
  448.                                     }
  449.                                     ┬º┬ºgoto(addr610);
  450.                                     ┬º┬ºpush(eval("\x01") != 700);
  451.                                  }
  452.                                  set("\x01",eval("\x01") - 582);
  453.                                  break loop0;
  454.                               }
  455.                               set("\x01",eval("\x01") - 308);
  456.                               addr1989:
  457.                               if(┬º┬ºpop())
  458.                               {
  459.                                  if(eval("\x01") == 317)
  460.                                  {
  461.                                     set("\x01",eval("\x01") + 97);
  462.                                     addr1965:
  463.                                     if(eval("\x01") == 911)
  464.                                     {
  465.                                        set("\x01",eval("\x01") - 535);
  466.                                        ┬º┬ºgoto(addr1965);
  467.                                        ┬º┬ºpush(true);
  468.                                     }
  469.                                     ┬º┬ºgoto(addr1989);
  470.                                     ┬º┬ºpush(eval("\x01") != 951);
  471.                                  }
  472.                                  if(eval("\x01") == 15)
  473.                                  {
  474.                                     set("\x01",eval("\x01") + 550);
  475.                                     if(!┬º┬ºpop())
  476.                                     {
  477.                                        addr2032:
  478.                                        ┬º┬ºgoto(addr1965);
  479.                                     }
  480.                                     set("\x01",eval("\x01") - 336);
  481.                                     ┬º┬ºgoto(addr2032);
  482.                                  }
  483.                                  if(eval("\x01") == 690)
  484.                                  {
  485.                                     set("\x01",eval("\x01") - 113);
  486.                                     ┬º┬ºgoto(addr1965);
  487.                                     ┬º┬ºpush(true);
  488.                                  }
  489.                                  if(eval("\x01") == 376)
  490.                                  {
  491.                                     set("\x01",eval("\x01") + 551);
  492.                                     if(!┬º┬ºpop())
  493.                                     {
  494.                                        addr2067:
  495.                                        ┬º┬ºgoto(addr1965);
  496.                                     }
  497.                                     set("\x01",eval("\x01") - 911);
  498.                                     ┬º┬ºgoto(addr2067);
  499.                                  }
  500.                                  if(eval("\x01") == 768)
  501.                                  {
  502.                                     set("\x01",eval("\x01") - 753);
  503.                                     ┬º┬ºgoto(addr1965);
  504.                                     ┬º┬ºpush(true);
  505.                                  }
  506.                                  if(eval("\x01") == 54)
  507.                                  {
  508.                                     set("\x01",eval("\x01") + 609);
  509.                                     ┬º┬ºgoto(addr1965);
  510.                                  }
  511.                                  if(eval("\x01") == 201)
  512.                                  {
  513.                                     set("\x01",eval("\x01") + 390);
  514.                                     ┬º┬ºgoto(addr1965);
  515.                                  }
  516.                                  if(eval("\x01") == 247)
  517.                                  {
  518.                                     set("\x01",eval("\x01") - 154);
  519.                                     ┬º┬ºgoto(addr1965);
  520.                                  }
  521.                                  if(eval("\x01") == 69)
  522.                                  {
  523.                                     set("\x01",eval("\x01") + 24);
  524.                                     ┬º┬ºgoto(addr1965);
  525.                                  }
  526.                                  if(eval("\x01") == 577)
  527.                                  {
  528.                                     set("\x01",eval("\x01") - 476);
  529.                                     if(!┬º┬ºpop())
  530.                                     {
  531.                                        addr2155:
  532.                                        ┬º┬ºgoto(addr1965);
  533.                                     }
  534.                                     set("\x01",eval("\x01") + 825);
  535.                                     ┬º┬ºgoto(addr2155);
  536.                                  }
  537.                                  addr2171:
  538.                                  if(eval("\x01") == 591)
  539.                                  {
  540.                                     set("\x01",eval("\x01") - 501);
  541.                                     ┬º┬ºgoto(addr1965);
  542.                                     ┬º┬ºpush(true);
  543.                                  }
  544.                                  if(eval("\x01") == 94)
  545.                                  {
  546.                                     set("\x01",eval("\x01") + 857);
  547.                                     ┬º┬ºgoto(addr1965);
  548.                                  }
  549.                                  if(eval("\x01") != 178)
  550.                                  {
  551.                                     if(eval("\x01") != 490)
  552.                                     {
  553.                                        if(eval("\x01") != 366)
  554.                                        {
  555.                                           if(eval("\x01") == 952)
  556.                                           {
  557.                                              set("\x01",eval("\x01") - 774);
  558.                                              if(!┬º┬ºpop())
  559.                                              {
  560.                                                 addr2242:
  561.                                                 ┬º┬ºgoto(addr1965);
  562.                                              }
  563.                                              set("\x01",eval("\x01") - 124);
  564.                                              ┬º┬ºgoto(addr2242);
  565.                                           }
  566.                                           if(eval("\x01") == 364)
  567.                                           {
  568.                                              set("\x01",eval("\x01") + 484);
  569.                                              if(!┬º┬ºpop())
  570.                                              {
  571.                                                 addr2263:
  572.                                                 ┬º┬ºgoto(addr1965);
  573.                                              }
  574.                                              set("\x01",eval("\x01") - 647);
  575.                                              ┬º┬ºgoto(addr2263);
  576.                                           }
  577.                                           if(eval("\x01") != 927)
  578.                                           {
  579.                                              if(eval("\x01") == 601)
  580.                                              {
  581.                                                 set("\x01",eval("\x01") - 237);
  582.                                                 ┬º┬ºgoto(addr1965);
  583.                                                 ┬º┬ºpush(true);
  584.                                              }
  585.                                              if(eval("\x01") == 228)
  586.                                              {
  587.                                                 set("\x01",eval("\x01") + 462);
  588.                                                 ┬º┬ºgoto(addr1965);
  589.                                              }
  590.                                              if(eval("\x01") != 101)
  591.                                              {
  592.                                                 if(eval("\x01") == 918)
  593.                                                 {
  594.                                                    set("\x01",eval("\x01") - 255);
  595.                                                    ┬º┬ºgoto(addr1965);
  596.                                                 }
  597.                                                 if(eval("\x01") == 108)
  598.                                                 {
  599.                                                    set("\x01",eval("\x01") + 322);
  600.                                                    ┬º┬ºgoto(addr1965);
  601.                                                 }
  602.                                                 if(eval("\x01") == 663)
  603.                                                 {
  604.                                                    set("\x01",eval("\x01") + 111);
  605.                                                    ┬º┬ºgoto(addr1965);
  606.                                                    ┬º┬ºpush(true);
  607.                                                 }
  608.                                                 if(eval("\x01") == 830)
  609.                                                 {
  610.                                                    set("\x01",eval("\x01") - 239);
  611.                                                    ┬º┬ºgoto(addr1965);
  612.                                                 }
  613.                                                 if(eval("\x01") == 474)
  614.                                                 {
  615.                                                    set("\x01",eval("\x01") + 294);
  616.                                                    ┬º┬ºgoto(addr1965);
  617.                                                 }
  618.                                                 if(eval("\x01") == 965)
  619.                                                 {
  620.                                                    set("\x01",eval("\x01") - 13);
  621.                                                    ┬º┬ºgoto(addr1965);
  622.                                                    ┬º┬ºpush(true);
  623.                                                 }
  624.                                                 if(eval("\x01") == 29)
  625.                                                 {
  626.                                                    set("\x01",eval("\x01") + 739);
  627.                                                    ┬º┬ºgoto(addr1965);
  628.                                                 }
  629.                                                 if(eval("\x01") != 848)
  630.                                                 {
  631.                                                    if(eval("\x01") == 168)
  632.                                                    {
  633.                                                       set("\x01",eval("\x01") + 433);
  634.                                                       ┬º┬ºgoto(addr1965);
  635.                                                    }
  636.                                                    if(eval("\x01") == 459)
  637.                                                    {
  638.                                                       set("\x01",eval("\x01") + 506);
  639.                                                       ┬º┬ºgoto(addr1965);
  640.                                                    }
  641.                                                    if(eval("\x01") == 414)
  642.                                                    {
  643.                                                       set("\x01",eval("\x01") + 134);
  644.                                                       ┬º┬ºgoto(addr1965);
  645.                                                       ┬º┬ºpush(true);
  646.                                                    }
  647.                                                    if(eval("\x01") == 314)
  648.                                                    {
  649.                                                       set("\x01",eval("\x01") + 651);
  650.                                                       ┬º┬ºgoto(addr1965);
  651.                                                    }
  652.                                                    if(eval("\x01") != 789)
  653.                                                    {
  654.                                                       if(eval("\x01") == 926)
  655.                                                       {
  656.                                                          set("\x01",eval("\x01") - 325);
  657.                                                          ┬º┬ºgoto(addr1965);
  658.                                                       }
  659.                                                       if(eval("\x01") == 90)
  660.                                                       {
  661.                                                          set("\x01",eval("\x01") + 400);
  662.                                                          if(!┬º┬ºpop())
  663.                                                          {
  664.                                                             addr2530:
  665.                                                             ┬º┬ºgoto(addr1965);
  666.                                                          }
  667.                                                          set("\x01",eval("\x01") - 176);
  668.                                                          ┬º┬ºgoto(addr2530);
  669.                                                       }
  670.                                                       if(eval("\x01") != 245)
  671.                                                       {
  672.                                                          if(eval("\x01") == 774)
  673.                                                          {
  674.                                                             set("\x01",eval("\x01") + 15);
  675.                                                             if(!┬º┬ºpop())
  676.                                                             {
  677.                                                                addr2564:
  678.                                                                ┬º┬ºgoto(addr1965);
  679.                                                             }
  680.                                                             set("\x01",eval("\x01") - 720);
  681.                                                             ┬º┬ºgoto(addr2564);
  682.                                                          }
  683.                                                          if(eval("\x01") == 696)
  684.                                                          {
  685.                                                             set("\x01",eval("\x01") - 6);
  686.                                                             ┬º┬ºgoto(addr1965);
  687.                                                          }
  688.                                                          if(eval("\x01") == 548)
  689.                                                          {
  690.                                                             set("\x01",eval("\x01") - 303);
  691.                                                             if(!┬º┬ºpop())
  692.                                                             {
  693.                                                                addr2599:
  694.                                                                ┬º┬ºgoto(addr1965);
  695.                                                             }
  696.                                                             set("\x01",eval("\x01") - 216);
  697.                                                             ┬º┬ºgoto(addr2599);
  698.                                                          }
  699.                                                          if(eval("\x01") == 16)
  700.                                                          {
  701.                                                             set("\x01",eval("\x01") + 398);
  702.                                                             ┬º┬ºgoto(addr1965);
  703.                                                          }
  704.                                                          if(eval("\x01") != 565)
  705.                                                          {
  706.                                                             if(eval("\x01") == 229)
  707.                                                             {
  708.                                                                set("\x01",eval("\x01") + 201);
  709.                                                                ┬º┬ºgoto(addr1965);
  710.                                                             }
  711.                                                             if(eval("\x01") == 682)
  712.                                                             {
  713.                                                                set("\x01",eval("\x01") - 316);
  714.                                                                if(!┬º┬ºpop())
  715.                                                                {
  716.                                                                   addr2659:
  717.                                                                   ┬º┬ºgoto(addr1965);
  718.                                                                }
  719.                                                                set("\x01",eval("\x01") - 138);
  720.                                                                ┬º┬ºgoto(addr2659);
  721.                                                             }
  722.                                                             if(eval("\x01") == 430)
  723.                                                             {
  724.                                                                set("\x01",eval("\x01") + 252);
  725.                                                                ┬º┬ºgoto(addr1965);
  726.                                                                ┬º┬ºpush(true);
  727.                                                             }
  728.                                                             if(eval("\x01") == 252)
  729.                                                             {
  730.                                                                set("\x01",eval("\x01") + 699);
  731.                                                                ┬º┬ºgoto(addr1965);
  732.                                                             }
  733.                                                             if(eval("\x01") == 93)
  734.                                                             {
  735.                                                                set("\x01",eval("\x01") + 586);
  736.                                                                ┬º┬ºgoto(addr1965);
  737.                                                                ┬º┬ºpush(true);
  738.                                                             }
  739.                                                             if(eval("\x01") == 679)
  740.                                                             {
  741.                                                                set("\x01",eval("\x01") - 159);
  742.                                                                if(!┬º┬ºpop())
  743.                                                                {
  744.                                                                   addr2722:
  745.                                                                   ┬º┬ºgoto(addr1965);
  746.                                                                }
  747.                                                                set("\x01",eval("\x01") - 426);
  748.                                                                ┬º┬ºgoto(addr2722);
  749.                                                             }
  750.                                                             if(eval("\x01") == 520)
  751.                                                             {
  752.                                                                set("\x01",eval("\x01") - 426);
  753.                                                                break loop0;
  754.                                                             }
  755.                                                             if(eval("\x01") == 338)
  756.                                                             {
  757.                                                                set("\x01",eval("\x01") - 338);
  758.                                                             }
  759.                                                             break loop0;
  760.                                                          }
  761.                                                          set("\x01",eval("\x01") - 336);
  762.                                                          ┬º┬ºpop()["{invalid_utf8=250}{invalid_utf8=237}"] = -71.3 + _loc1_["{invalid_utf8=219}>"]["{invalid_utf8=193}_y"]() * 1.9;
  763.                                                          set(┬º┬ºpop(),┬º┬ºpop());
  764.                                                          break loop0;
  765.                                                       }
  766.                                                       set("\x01",eval("\x01") - 216);
  767.                                                       ┬º┬ºpush(┬º┬ºpop() lt (┬º┬ºpop() == ┬º┬ºpop()));
  768.                                                       break loop0;
  769.                                                    }
  770.                                                    set("\x01",eval("\x01") - 720);
  771.                                                    prevFrame();
  772.                                                    break loop0;
  773.                                                 }
  774.                                                 set("\x01",eval("\x01") - 647);
  775.                                                 prevFrame();
  776.                                                 break loop0;
  777.                                              }
  778.                                              set("\x01",eval("\x01") + 825);
  779.                                              break loop0;
  780.                                           }
  781.                                           set("\x01",eval("\x01") - 911);
  782.                                           break loop0;
  783.                                        }
  784.                                        set("\x01",eval("\x01") - 138);
  785.                                        prevFrame();
  786.                                        break loop0;
  787.                                     }
  788.                                     set("\x01",eval("\x01") - 176);
  789.                                     play();
  790.                                     break loop0;
  791.                                  }
  792.                                  set("\x01",eval("\x01") - 124);
  793.                                  break loop0;
  794.                               }
  795.                               set("\x01",eval("\x01") - 613);
  796.                               removeMovieClip(_root.MouseOver);
  797.                               break loop0;
  798.                            }
  799.                            set("\x01",eval("\x01") + 592);
  800.                            break loop0;
  801.                         }
  802.                         set("\x01",eval("\x01") + 32);
  803.                         addr1012:
  804.                         set(┬º┬ºpop(),eval(┬º┬ºpop()) + 10);
  805.                         if(!┬º┬ºpop())
  806.                         {
  807.                            addr921:
  808.                            if(eval("\x01") == 530)
  809.                            {
  810.                               set("\x01",eval("\x01") - 487);
  811.                               ┬º┬ºgoto(addr921);
  812.                               ┬º┬ºpush(true);
  813.                            }
  814.                            if(eval("\x01") != 446)
  815.                            {
  816.                               if(eval("\x01") == 918)
  817.                               {
  818.                                  set("\x01",eval("\x01") - 714);
  819.                                  ┬º┬ºgoto(addr921);
  820.                               }
  821.                               if(eval("\x01") != 743)
  822.                               {
  823.                                  if(eval("\x01") != 795)
  824.                                  {
  825.                                     if(eval("\x01") == 154)
  826.                                     {
  827.                                        set("\x01",eval("\x01") + 519);
  828.                                        ┬º┬ºgoto(addr921);
  829.                                     }
  830.                                     if(eval("\x01") == 733)
  831.                                     {
  832.                                        ┬º┬ºgoto(addr1012);
  833.                                        ┬º┬ºpush("\x01");
  834.                                        ┬º┬ºpush("\x01");
  835.                                     }
  836.                                     if(eval("\x01") == 169)
  837.                                     {
  838.                                        set("\x01",eval("\x01") + 27);
  839.                                        ┬º┬ºgoto(addr921);
  840.                                     }
  841.                                     if(eval("\x01") == 479)
  842.                                     {
  843.                                        set("\x01",eval("\x01") + 194);
  844.                                        ┬º┬ºgoto(addr921);
  845.                                     }
  846.                                     addr734:
  847.                                     if(eval("\x01") != 311)
  848.                                     {
  849.                                        if(eval("\x01") == 147)
  850.                                        {
  851.                                           set("\x01",eval("\x01") + 551);
  852.                                           ┬º┬ºgoto(addr921);
  853.                                           ┬º┬ºpush(true);
  854.                                        }
  855.                                        if(eval("\x01") == 888)
  856.                                        {
  857.                                           set("\x01",eval("\x01") - 293);
  858.                                           ┬º┬ºgoto(addr921);
  859.                                        }
  860.                                        if(eval("\x01") == 204)
  861.                                        {
  862.                                           set("\x01",eval("\x01") + 729);
  863.                                           ┬º┬ºgoto(addr921);
  864.                                           ┬º┬ºpush(true);
  865.                                        }
  866.                                        if(eval("\x01") == 747)
  867.                                        {
  868.                                           set("\x01",eval("\x01") - 449);
  869.                                           ┬º┬ºgoto(addr921);
  870.                                        }
  871.                                        if(eval("\x01") == 933)
  872.                                        {
  873.                                           set("\x01",eval("\x01") - 138);
  874.                                           if(!┬º┬ºpop())
  875.                                           {
  876.                                              addr1140:
  877.                                              ┬º┬ºgoto(addr921);
  878.                                           }
  879.                                           set("\x01",eval("\x01") + 93);
  880.                                           ┬º┬ºgoto(addr1140);
  881.                                        }
  882.                                        if(eval("\x01") == 595)
  883.                                        {
  884.                                           set("\x01",eval("\x01") + 138);
  885.                                           ┬º┬ºgoto(addr921);
  886.                                           ┬º┬ºpush(true);
  887.                                        }
  888.                                        if(eval("\x01") == 673)
  889.                                        {
  890.                                           set("\x01",eval("\x01") - 625);
  891.                                           ┬º┬ºgoto(addr921);
  892.                                           ┬º┬ºpush(true);
  893.                                        }
  894.                                        if(eval("\x01") == 698)
  895.                                        {
  896.                                           set("\x01",eval("\x01") - 628);
  897.                                           if(!┬º┬ºpop())
  898.                                           {
  899.                                              addr1192:
  900.                                              ┬º┬ºgoto(addr921);
  901.                                           }
  902.                                           set("\x01",eval("\x01") + 404);
  903.                                           ┬º┬ºgoto(addr1192);
  904.                                        }
  905.                                        if(eval("\x01") == 544)
  906.                                        {
  907.                                           set("\x01",eval("\x01") - 340);
  908.                                           ┬º┬ºgoto(addr921);
  909.                                        }
  910.                                        if(eval("\x01") == 992)
  911.                                        {
  912.                                           set("\x01",eval("\x01") - 397);
  913.                                           ┬º┬ºgoto(addr921);
  914.                                        }
  915.                                        if(eval("\x01") == 48)
  916.                                        {
  917.                                           set("\x01",eval("\x01") + 398);
  918.                                           if(!┬º┬ºpop())
  919.                                           {
  920.                                              addr1241:
  921.                                              ┬º┬ºgoto(addr921);
  922.                                           }
  923.                                           set("\x01",eval("\x01") + 13);
  924.                                           ┬º┬ºgoto(addr1241);
  925.                                        }
  926.                                        if(eval("\x01") == 270)
  927.                                        {
  928.                                           set("\x01",eval("\x01") + 339);
  929.                                           ┬º┬ºgoto(addr921);
  930.                                        }
  931.                                        if(eval("\x01") != 70)
  932.                                        {
  933.                                           if(eval("\x01") != 818)
  934.                                           {
  935.                                              if(eval("\x01") == 293)
  936.                                              {
  937.                                                 set("\x01",eval("\x01") + 525);
  938.                                                 if(!┬º┬ºpop())
  939.                                                 {
  940.                                                    addr1301:
  941.                                                    ┬º┬ºgoto(addr921);
  942.                                                 }
  943.                                                 set("\x01",eval("\x01") + 100);
  944.                                                 ┬º┬ºgoto(addr1301);
  945.                                              }
  946.                                              if(eval("\x01") == 811)
  947.                                              {
  948.                                                 set("\x01",eval("\x01") - 664);
  949.                                                 ┬º┬ºgoto(addr921);
  950.                                              }
  951.                                              if(eval("\x01") != 902)
  952.                                              {
  953.                                                 if(eval("\x01") == 459)
  954.                                                 {
  955.                                                    set("\x01",eval("\x01") - 312);
  956.                                                    ┬º┬ºgoto(addr921);
  957.                                                 }
  958.                                                 if(eval("\x01") == 457)
  959.                                                 {
  960.                                                    set("\x01",eval("\x01") - 146);
  961.                                                    if(!┬º┬ºpop())
  962.                                                    {
  963.                                                       addr1363:
  964.                                                       ┬º┬ºgoto(addr921);
  965.                                                    }
  966.                                                    set("\x01",eval("\x01") + 168);
  967.                                                    ┬º┬ºgoto(addr1363);
  968.                                                 }
  969.                                                 if(eval("\x01") == 609)
  970.                                                 {
  971.                                                    set("\x01",eval("\x01") - 152);
  972.                                                    ┬º┬ºgoto(addr921);
  973.                                                    ┬º┬ºpush(true);
  974.                                                 }
  975.                                                 if(eval("\x01") == 196)
  976.                                                 {
  977.                                                    set("\x01",eval("\x01") + 97);
  978.                                                    ┬º┬ºgoto(addr921);
  979.                                                    ┬º┬ºpush(true);
  980.                                                 }
  981.                                                 if(eval("\x01") == 474)
  982.                                                 {
  983.                                                    set("\x01",eval("\x01") - 176);
  984.                                                    ┬º┬ºgoto(addr921);
  985.                                                 }
  986.                                                 if(eval("\x01") == 298)
  987.                                                 {
  988.                                                    set("\x01",eval("\x01") + 604);
  989.                                                    ┬º┬ºgoto(addr921);
  990.                                                 }
  991.                                                 if(eval("\x01") != 966)
  992.                                                 {
  993.                                                    if(eval("\x01") != 2)
  994.                                                    {
  995.                                                       if(eval("\x01") == 43)
  996.                                                       {
  997.                                                          set("\x01",eval("\x01") - 41);
  998.                                                          if(!┬º┬ºpop())
  999.                                                          {
  1000.                                                             addr1465:
  1001.                                                             ┬º┬ºgoto(addr921);
  1002.                                                          }
  1003.                                                          set("\x01",eval("\x01") + 985);
  1004.                                                          ┬º┬ºgoto(addr1465);
  1005.                                                       }
  1006.                                                       if(eval("\x01") == 987)
  1007.                                                       {
  1008.                                                          set("\x01",eval("\x01") - 791);
  1009.                                                          ┬º┬ºgoto(addr921);
  1010.                                                       }
  1011.                                                       if(eval("\x01") == 852)
  1012.                                                       {
  1013.                                                          set("\x01",eval("\x01") - 243);
  1014.                                                          ┬º┬ºgoto(addr921);
  1015.                                                       }
  1016.                                                       break loop0;
  1017.                                                    }
  1018.                                                    set("\x01",eval("\x01") + 985);
  1019.                                                    addr3047:
  1020.                                                    set("\x01",eval("\x01") + 92);
  1021.                                                    while(eval("\x01") == 814)
  1022.                                                    {
  1023.                                                       set("\x01",eval("\x01") - 275);
  1024.                                                       ┬º┬ºpush(true);
  1025.                                                    }
  1026.                                                    ┬º┬ºpush("\x01");
  1027.                                                    while(true)
  1028.                                                    {
  1029.                                                       if(eval(┬º┬ºpop()) == 206)
  1030.                                                       {
  1031.                                                          set("\x01",eval("\x01") + 381);
  1032.                                                          continue;
  1033.                                                       }
  1034.                                                       if(eval("\x01") == 163)
  1035.                                                       {
  1036.                                                          set("\x01",eval("\x01") + 131);
  1037.                                                          if(┬º┬ºpop())
  1038.                                                          {
  1039.                                                             set("\x01",eval("\x01") + 169);
  1040.                                                          }
  1041.                                                          continue;
  1042.                                                       }
  1043.                                                       if(eval("\x01") == 294)
  1044.                                                       {
  1045.                                                          set("\x01",eval("\x01") + 169);
  1046.                                                          break loop0;
  1047.                                                       }
  1048.                                                       if(eval("\x01") == 259)
  1049.                                                       {
  1050.                                                          set("\x01",eval("\x01") - 96);
  1051.                                                          ┬º┬ºpush(true);
  1052.                                                          continue;
  1053.                                                       }
  1054.                                                       if(eval("\x01") == 824)
  1055.                                                       {
  1056.                                                          set("\x01",eval("\x01") - 293);
  1057.                                                          break loop0;
  1058.                                                       }
  1059.                                                       if(eval("\x01") == 237)
  1060.                                                       {
  1061.                                                          set("\x01",eval("\x01") + 215);
  1062.                                                          continue;
  1063.                                                       }
  1064.                                                       if(eval("\x01") == 587)
  1065.                                                       {
  1066.                                                          set("\x01",eval("\x01") - 115);
  1067.                                                          ┬º┬ºpush(true);
  1068.                                                          continue;
  1069.                                                       }
  1070.                                                       if(eval("\x01") == 539)
  1071.                                                       {
  1072.                                                          set("\x01",eval("\x01") + 384);
  1073.                                                          if(┬º┬ºpop())
  1074.                                                          {
  1075.                                                             set("\x01",eval("\x01") - 137);
  1076.                                                          }
  1077.                                                          continue;
  1078.                                                       }
  1079.                                                       if(eval("\x01") == 923)
  1080.                                                       {
  1081.                                                          set("\x01",eval("\x01") - 137);
  1082.                                                          break loop0;
  1083.                                                       }
  1084.                                                       if(eval("\x01") == 786)
  1085.                                                       {
  1086.                                                          set("\x01",eval("\x01") - 44);
  1087.                                                          continue;
  1088.                                                       }
  1089.                                                       if(eval("\x01") == 463)
  1090.                                                       {
  1091.                                                          set("\x01",eval("\x01") + 334);
  1092.                                                          continue;
  1093.                                                       }
  1094.                                                       if(eval("\x01") == 508)
  1095.                                                       {
  1096.                                                          set("\x01",eval("\x01") + 81);
  1097.                                                          if(┬º┬ºpop())
  1098.                                                          {
  1099.                                                             set("\x01",eval("\x01") - 352);
  1100.                                                          }
  1101.                                                          continue;
  1102.                                                       }
  1103.                                                       if(eval("\x01") == 689)
  1104.                                                       {
  1105.                                                          set("\x01",eval("\x01") - 181);
  1106.                                                          ┬º┬ºpush(true);
  1107.                                                          continue;
  1108.                                                       }
  1109.                                                       if(eval("\x01") == 589)
  1110.                                                       {
  1111.                                                          set("\x01",eval("\x01") - 352);
  1112.                                                          break loop0;
  1113.                                                       }
  1114.                                                       if(eval("\x01") == 472)
  1115.                                                       {
  1116.                                                          set("\x01",eval("\x01") + 352);
  1117.                                                          if(┬º┬ºpop())
  1118.                                                          {
  1119.                                                             set("\x01",eval("\x01") - 293);
  1120.                                                          }
  1121.                                                          continue;
  1122.                                                       }
  1123.                                                       if(eval("\x01") == 643)
  1124.                                                       {
  1125.                                                          set("\x01",eval("\x01") - 384);
  1126.                                                          continue;
  1127.                                                       }
  1128.                                                       if(eval("\x01") == 781)
  1129.                                                       {
  1130.                                                          set("\x01",eval("\x01") - 522);
  1131.                                                          continue;
  1132.                                                       }
  1133.                                                       if(eval("\x01") != 797)
  1134.                                                       {
  1135.                                                          if(eval("\x01") == 588)
  1136.                                                          {
  1137.                                                             set("\x01",eval("\x01") + 101);
  1138.                                                          }
  1139.                                                          else if(eval("\x01") == 487)
  1140.                                                          {
  1141.                                                             set("\x01",eval("\x01") + 310);
  1142.                                                          }
  1143.                                                          else if(eval("\x01") == 509)
  1144.                                                          {
  1145.                                                             set("\x01",eval("\x01") - 57);
  1146.                                                          }
  1147.                                                          else if(eval("\x01") == 343)
  1148.                                                          {
  1149.                                                             set("\x01",eval("\x01") + 244);
  1150.                                                          }
  1151.                                                          else
  1152.                                                          {
  1153.                                                             if(eval("\x01") == 348)
  1154.                                                             {
  1155.                                                                set("\x01",eval("\x01") - 142);
  1156.                                                                break loop0;
  1157.                                                             }
  1158.                                                             if(eval("\x01") == 365)
  1159.                                                             {
  1160.                                                                set("\x01",eval("\x01") + 278);
  1161.                                                                break loop0;
  1162.                                                             }
  1163.                                                             if(eval("\x01") == 531)
  1164.                                                             {
  1165.                                                                set("\x01",eval("\x01") + 158);
  1166.                                                             }
  1167.                                                             else
  1168.                                                             {
  1169.                                                                if(eval("\x01") == 889)
  1170.                                                                {
  1171.                                                                   set("\x01",eval("\x01") - 482);
  1172.                                                                   eval("{invalid_utf8=191}\x1c")[┬º┬ºconstant(3)](┬º┬ºconstant(2),┬º┬ºconstant(2),eval("{invalid_utf8=191}\x1c")["{invalid_utf8=185}{invalid_utf8=221}@{invalid_utf8=238}\t"]());
  1173.                                                                   break loop0;
  1174.                                                                }
  1175.                                                                if(eval("\x01") == 407)
  1176.                                                                {
  1177.                                                                   set("\x01",eval("\x01") - 407);
  1178.                                                                   break loop0;
  1179.                                                                }
  1180.                                                                if(eval("\x01") == 413)
  1181.                                                                {
  1182.                                                                   set("\x01",eval("\x01") - 48);
  1183.                                                                   if(┬º┬ºpop())
  1184.                                                                   {
  1185.                                                                      set("\x01",eval("\x01") + 278);
  1186.                                                                   }
  1187.                                                                }
  1188.                                                                else if(eval("\x01") == 49)
  1189.                                                                {
  1190.                                                                   set("\x01",eval("\x01") + 299);
  1191.                                                                   if(┬º┬ºpop())
  1192.                                                                   {
  1193.                                                                      set("\x01",eval("\x01") - 142);
  1194.                                                                   }
  1195.                                                                }
  1196.                                                                else if(eval("\x01") == 452)
  1197.                                                                {
  1198.                                                                   set("\x01",eval("\x01") - 39);
  1199.                                                                   ┬º┬ºpush(true);
  1200.                                                                }
  1201.                                                                else if(eval("\x01") == 742)
  1202.                                                                {
  1203.                                                                   set("\x01",eval("\x01") - 693);
  1204.                                                                   ┬º┬ºpush(true);
  1205.                                                                }
  1206.                                                                else
  1207.                                                                {
  1208.                                                                   if(eval("\x01") != 877)
  1209.                                                                   {
  1210.                                                                      break loop0;
  1211.                                                                   }
  1212.                                                                   set("\x01",eval("\x01") - 135);
  1213.                                                                }
  1214.                                                             }
  1215.                                                          }
  1216.                                                          continue;
  1217.                                                       }
  1218.                                                       ┬º┬ºgoto(addr3047);
  1219.                                                    }
  1220.                                                    addr2767:
  1221.                                                    addr2785:
  1222.                                                 }
  1223.                                                 set("\x01",eval("\x01") - 966);
  1224.                                                 break loop0;
  1225.                                              }
  1226.                                              set("\x01",eval("\x01") + 64);
  1227.                                              eval("{invalid_utf8=153}){invalid_utf8=249}")[┬º┬ºconstant(3)]("{invalid_utf8=196}u\r{invalid_utf8=249}∩┐╜F","{invalid_utf8=196}u\r{invalid_utf8=249}∩┐╜F",eval("{invalid_utf8=153}){invalid_utf8=249}")["{invalid_utf8=153}{invalid_utf8=131}{invalid_utf8=237}{invalid_utf8=213}{invalid_utf8=42}{invalid_utf8=206}4\x06"]());
  1228.                                              removeMovieClip(eval("{invalid_utf8=153}){invalid_utf8=249}")["{invalid_utf8=196}u\r{invalid_utf8=249}∩┐╜F"]);
  1229.                                              delete eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)];
  1230.                                              break loop0;
  1231.                                           }
  1232.                                           set("\x01",eval("\x01") + 100);
  1233.                                           addr25:
  1234.                                           if(eval("\x01") == 526)
  1235.                                           {
  1236.                                              set("\x01",eval("\x01") - 398);
  1237.                                              ┬º┬ºgoto(addr25);
  1238.                                              ┬º┬ºpush(true);
  1239.                                           }
  1240.                                           addr102:
  1241.                                           if(eval("\x01") != 619)
  1242.                                           {
  1243.                                              if(eval("\x01") == 128)
  1244.                                              {
  1245.                                                 set("\x01",eval("\x01") + 491);
  1246.                                                 if(!┬º┬ºpop())
  1247.                                                 {
  1248.                                                    addr75:
  1249.                                                    ┬º┬ºgoto(addr25);
  1250.                                                 }
  1251.                                                 set("\x01",eval("\x01") - 360);
  1252.                                                 ┬º┬ºgoto(addr75);
  1253.                                              }
  1254.                                              if(eval("\x01") == 259)
  1255.                                              {
  1256.                                                 set("\x01",eval("\x01") + 690);
  1257.                                                 ┬º┬ºgoto(addr25);
  1258.                                              }
  1259.                                              if(eval("\x01") == 706)
  1260.                                              {
  1261.                                                 set("\x01",eval("\x01") + 243);
  1262.                                                 ┬º┬ºgoto(addr102);
  1263.                                              }
  1264.                                              if(eval("\x01") == 949)
  1265.                                              {
  1266.                                                 set("\x01",eval("\x01") - 652);
  1267.                                                 stop();
  1268.                                                 break loop0;
  1269.                                              }
  1270.                                              if(eval("\x01") == 297)
  1271.                                              {
  1272.                                                 set("\x01",eval("\x01") - 297);
  1273.                                              }
  1274.                                              break loop0;
  1275.                                           }
  1276.                                           set("\x01",eval("\x01") - 360);
  1277.                                           set(┬º┬ºpop(),┬º┬ºpop());
  1278.                                           ┬º┬ºgoto(addr2171);
  1279.                                        }
  1280.                                        set("\x01",eval("\x01") + 404);
  1281.                                        call(┬º┬ºpop());
  1282.                                        ┬º┬ºpush(┬º┬ºpop());
  1283.                                        break loop0;
  1284.                                     }
  1285.                                     set("\x01",eval("\x01") + 168);
  1286.                                     set(┬º┬ºpop(),┬º┬ºpop() + 206);
  1287.                                     eval("+){invalid_utf8=151}")[";{invalid_utf8=159}\x1a{invalid_utf8=208}"]();
  1288.                                     delete eval("+){invalid_utf8=151}")[┬º┬ºconstant(2)];
  1289.                                     break loop0;
  1290.                                  }
  1291.                                  set("\x01",eval("\x01") + 93);
  1292.                                  break loop0;
  1293.                               }
  1294.                               set("\x01",eval("\x01") - 473);
  1295.                               break loop0;
  1296.                            }
  1297.                            set("\x01",eval("\x01") + 13);
  1298.                            prevFrame();
  1299.                            break loop0;
  1300.                            addr1024:
  1301.                         }
  1302.                         set("\x01",eval("\x01") - 473);
  1303.                         ┬º┬ºgoto(addr1024);
  1304.                      }
  1305.                      if(eval("\x01") == 315)
  1306.                      {
  1307.                         set("\x01",eval("\x01") + 178);
  1308.                         ┬º┬ºgoto(addr148);
  1309.                      }
  1310.                      if(eval("\x01") == 701)
  1311.                      {
  1312.                         set("\x01",eval("\x01") + 235);
  1313.                         ┬º┬ºgoto(addr148);
  1314.                         ┬º┬ºpush(true);
  1315.                      }
  1316.                      if(eval("\x01") == 789)
  1317.                      {
  1318.                         set("\x01",eval("\x01") - 246);
  1319.                         ┬º┬ºgoto(addr148);
  1320.                      }
  1321.                      if(eval("\x01") == 493)
  1322.                      {
  1323.                         set("\x01",eval("\x01") + 330);
  1324.                         ┬º┬ºgoto(addr148);
  1325.                         ┬º┬ºpush(true);
  1326.                      }
  1327.                      if(eval("\x01") == 570)
  1328.                      {
  1329.                         set("\x01",eval("\x01") + 131);
  1330.                         ┬º┬ºgoto(addr148);
  1331.                      }
  1332.                      if(eval("\x01") != 677)
  1333.                      {
  1334.                         if(eval("\x01") == 313)
  1335.                         {
  1336.                            set("\x01",eval("\x01") - 286);
  1337.                            ┬º┬ºgoto(addr148);
  1338.                            ┬º┬ºpush(true);
  1339.                         }
  1340.                         if(eval("\x01") != 448)
  1341.                         {
  1342.                            if(eval("\x01") == 574)
  1343.                            {
  1344.                               set("\x01",eval("\x01") - 261);
  1345.                               ┬º┬ºgoto(addr148);
  1346.                            }
  1347.                            if(eval("\x01") == 63)
  1348.                            {
  1349.                               set("\x01",eval("\x01") + 595);
  1350.                               ┬º┬ºgoto(addr148);
  1351.                            }
  1352.                            if(eval("\x01") != 974)
  1353.                            {
  1354.                               if(eval("\x01") == 679)
  1355.                               {
  1356.                                  set("\x01",eval("\x01") - 475);
  1357.                                  ┬º┬ºgoto(addr148);
  1358.                                  ┬º┬ºpush(true);
  1359.                               }
  1360.                               if(eval("\x01") != 654)
  1361.                               {
  1362.                                  if(eval("\x01") == 949)
  1363.                                  {
  1364.                                     set("\x01",eval("\x01") - 270);
  1365.                                     ┬º┬ºgoto(addr148);
  1366.                                  }
  1367.                                  if(eval("\x01") != 544)
  1368.                                  {
  1369.                                     if(eval("\x01") == 77)
  1370.                                     {
  1371.                                        set("\x01",eval("\x01") + 581);
  1372.                                        ┬º┬ºgoto(addr148);
  1373.                                     }
  1374.                                     if(eval("\x01") == 190)
  1375.                                     {
  1376.                                        set("\x01",eval("\x01") + 616);
  1377.                                        ┬º┬ºgoto(addr148);
  1378.                                     }
  1379.                                     if(eval("\x01") == 286)
  1380.                                     {
  1381.                                        set("\x01",eval("\x01") - 96);
  1382.                                     }
  1383.                                     break loop0;
  1384.                                  }
  1385.                                  set("\x01",eval("\x01") - 467);
  1386.                                  break loop0;
  1387.                               }
  1388.                               set("\x01",eval("\x01") - 654);
  1389.                               break loop0;
  1390.                            }
  1391.                            set("\x01",eval("\x01") - 404);
  1392.                            var ┬º┬ºpop() = ┬º┬ºpop();
  1393.                            break loop0;
  1394.                         }
  1395.                         ┬º┬ºgoto(addr734);
  1396.                         ┬º┬ºpush("\x01");
  1397.                         ┬º┬ºpush(eval("\x01"));
  1398.                      }
  1399.                      set("\x01",eval("\x01") + 112);
  1400.                      break loop0;
  1401.                   }
  1402.                   set("\x01",eval("\x01") + 30);
  1403.                   break loop0;
  1404.                }
  1405.                if(eval("\x01") == 488)
  1406.                {
  1407.                   set("\x01",eval("\x01") - 173);
  1408.                   continue;
  1409.                }
  1410.                if(eval("\x01") == 76)
  1411.                {
  1412.                   set("\x01",eval("\x01") + 374);
  1413.                   break loop0;
  1414.                }
  1415.                if(eval("\x01") == 423)
  1416.                {
  1417.                   set("\x01",eval("\x01") + 119);
  1418.                   continue;
  1419.                }
  1420.                if(eval("\x01") == 953)
  1421.                {
  1422.                   set("\x01",eval("\x01") - 215);
  1423.                   if(┬º┬ºpop())
  1424.                   {
  1425.                      set("\x01",eval("\x01") - 250);
  1426.                   }
  1427.                   continue;
  1428.                }
  1429.                if(eval("\x01") == 315)
  1430.                {
  1431.                   set("\x01",eval("\x01") + 594);
  1432.                   ┬º┬ºpush(true);
  1433.                   continue;
  1434.                }
  1435.                if(eval("\x01") == 761)
  1436.                {
  1437.                   set("\x01",eval("\x01") - 137);
  1438.                   continue;
  1439.                }
  1440.                if(eval("\x01") == 624)
  1441.                {
  1442.                   set("\x01",eval("\x01") + 329);
  1443.                   ┬º┬ºpush(true);
  1444.                   continue;
  1445.                }
  1446.                if(eval("\x01") == 450)
  1447.                {
  1448.                   set("\x01",eval("\x01") - 188);
  1449.                   continue;
  1450.                }
  1451.                if(eval("\x01") == 879)
  1452.                {
  1453.                   set("\x01",eval("\x01") - 118);
  1454.                   break loop0;
  1455.                }
  1456.                continue loop6;
  1457.             }
  1458.          }
  1459.       }
  1460.    }
  1461.    else
  1462.    {
  1463.       if(eval("\x01") == 228)
  1464.       {
  1465.          set("\x01",eval("\x01") + 209);
  1466.          if(┬º┬ºpop())
  1467.          {
  1468.             set("\x01",eval("\x01") - 428);
  1469.          }
  1470.          continue;
  1471.       }
  1472.       if(eval("\x01") == 437)
  1473.       {
  1474.          set("\x01",eval("\x01") - 428);
  1475.          break;
  1476.       }
  1477.       if(eval("\x01") == 78)
  1478.       {
  1479.          set("\x01",eval("\x01") + 736);
  1480.          break;
  1481.       }
  1482.       if(eval("\x01") == 814)
  1483.       {
  1484.          set("\x01",eval("\x01") + 50);
  1485.          continue;
  1486.       }
  1487.       if(eval("\x01") == 107)
  1488.       {
  1489.          set("\x01",eval("\x01") + 326);
  1490.          if(┬º┬ºpop())
  1491.          {
  1492.             set("\x01",eval("\x01") - 235);
  1493.          }
  1494.          continue;
  1495.       }
  1496.       if(eval("\x01") == 835)
  1497.       {
  1498.          set("\x01",eval("\x01") - 264);
  1499.       }
  1500.       if(eval("\x01") == 659)
  1501.       {
  1502.          set("\x01",eval("\x01") - 636);
  1503.          if(┬º┬ºpop())
  1504.          {
  1505.             set("\x01",eval("\x01") + 369);
  1506.          }
  1507.          continue;
  1508.       }
  1509.       if(eval("\x01") == 469)
  1510.       {
  1511.          set("\x01",eval("\x01") + 147);
  1512.          ┬º┬ºpush(true);
  1513.          continue;
  1514.       }
  1515.       if(eval("\x01") == 448)
  1516.       {
  1517.          set("\x01",eval("\x01") + 416);
  1518.          continue;
  1519.       }
  1520.       if(eval("\x01") == 963)
  1521.       {
  1522.          set("\x01",eval("\x01") + 1);
  1523.          ┬º┬ºpush(true);
  1524.          continue;
  1525.       }
  1526.       if(eval("\x01") == 9)
  1527.       {
  1528.          set("\x01",eval("\x01") + 139);
  1529.          continue;
  1530.       }
  1531.       if(eval("\x01") == 616)
  1532.       {
  1533.          set("\x01",eval("\x01") + 212);
  1534.          if(┬º┬ºpop())
  1535.          {
  1536.             set("\x01",eval("\x01") - 338);
  1537.          }
  1538.          continue;
  1539.       }
  1540.       if(eval("\x01") == 258)
  1541.       {
  1542.          set("\x01",eval("\x01") - 151);
  1543.          ┬º┬ºpush(true);
  1544.          continue;
  1545.       }
  1546.       if(eval("\x01") == 57)
  1547.       {
  1548.          set("\x01",eval("\x01") + 250);
  1549.          if(┬º┬ºpop())
  1550.          {
  1551.             set("\x01",eval("\x01") + 681);
  1552.          }
  1553.          continue;
  1554.       }
  1555.       if(eval("\x01") == 148)
  1556.       {
  1557.          set("\x01",eval("\x01") - 91);
  1558.          ┬º┬ºpush(true);
  1559.          continue;
  1560.       }
  1561.       if(eval("\x01") == 392)
  1562.       {
  1563.          set("\x01",eval("\x01") + 77);
  1564.          continue;
  1565.       }
  1566.       if(eval("\x01") == 864)
  1567.       {
  1568.          set("\x01",eval("\x01") - 79);
  1569.          ┬º┬ºpush(true);
  1570.          continue;
  1571.       }
  1572.       if(eval("\x01") == 307)
  1573.       {
  1574.          set("\x01",eval("\x01") + 681);
  1575.          nextFrame();
  1576.          ┬º┬ºpush(int(getProperty(┬º┬ºpop(), _X)));
  1577.          break;
  1578.       }
  1579.       if(eval("\x01") == 262)
  1580.       {
  1581.          set("\x01",eval("\x01") + 331);
  1582.          continue;
  1583.       }
  1584.       if(eval("\x01") == 275)
  1585.       {
  1586.          set("\x01",eval("\x01") + 194);
  1587.          continue;
  1588.       }
  1589.       if(eval("\x01") == 181)
  1590.       {
  1591.          set("\x01",eval("\x01") + 108);
  1592.          continue;
  1593.       }
  1594.       if(eval("\x01") == 33)
  1595.       {
  1596.          set("\x01",eval("\x01") + 816);
  1597.          if(┬º┬ºpop())
  1598.          {
  1599.             set("\x01",eval("\x01") - 433);
  1600.          }
  1601.          continue;
  1602.       }
  1603.       if(eval("\x01") == 20)
  1604.       {
  1605.          set("\x01",eval("\x01") - 5);
  1606.          Help.MainMenu.onPress = function()
  1607.          {
  1608.             gotoAndStop(1);
  1609.          };
  1610.          break;
  1611.       }
  1612.       if(eval("\x01") == 849)
  1613.       {
  1614.          set("\x01",eval("\x01") - 433);
  1615.          break;
  1616.       }
  1617.       if(eval("\x01") == 53)
  1618.       {
  1619.          set("\x01",eval("\x01") + 95);
  1620.          continue;
  1621.       }
  1622.       if(eval("\x01") == 588)
  1623.       {
  1624.          set("\x01",eval("\x01") - 161);
  1625.          break;
  1626.       }
  1627.       if(eval("\x01") == 571)
  1628.       {
  1629.          set("\x01",eval("\x01") + 22);
  1630.          continue;
  1631.       }
  1632.       if(eval("\x01") == 301)
  1633.       {
  1634.          set("\x01",eval("\x01") - 73);
  1635.          ┬º┬ºpush(true);
  1636.          continue;
  1637.       }
  1638.       if(eval("\x01") == 266)
  1639.       {
  1640.          set("\x01",eval("\x01") + 697);
  1641.          continue;
  1642.       }
  1643.       if(eval("\x01") == 964)
  1644.       {
  1645.          set("\x01",eval("\x01") - 376);
  1646.          if(┬º┬ºpop())
  1647.          {
  1648.             set("\x01",eval("\x01") - 161);
  1649.          }
  1650.          continue;
  1651.       }
  1652.       if(eval("\x01") == 785)
  1653.       {
  1654.          set("\x01",eval("\x01") + 142);
  1655.          if(┬º┬ºpop())
  1656.          {
  1657.             set("\x01",eval("\x01") - 744);
  1658.          }
  1659.          continue;
  1660.       }
  1661.       if(eval("\x01") != 828)
  1662.       {
  1663.          if(eval("\x01") == 427)
  1664.          {
  1665.             set("\x01",eval("\x01") - 32);
  1666.          }
  1667.          else if(eval("\x01") == 768)
  1668.          {
  1669.             set("\x01",eval("\x01") - 510);
  1670.          }
  1671.          else if(eval("\x01") == 198)
  1672.          {
  1673.             set("\x01",eval("\x01") - 178);
  1674.          }
  1675.          else if(eval("\x01") == 71)
  1676.          {
  1677.             set("\x01",eval("\x01") + 7);
  1678.             if(┬º┬ºpop())
  1679.             {
  1680.                set("\x01",eval("\x01") + 736);
  1681.             }
  1682.          }
  1683.          else
  1684.          {
  1685.             if(eval("\x01") == 927)
  1686.             {
  1687.                set("\x01",eval("\x01") - 744);
  1688.                break;
  1689.             }
  1690.             if(eval("\x01") == 593)
  1691.             {
  1692.                set("\x01",eval("\x01") - 522);
  1693.                ┬º┬ºpush(true);
  1694.             }
  1695.             else
  1696.             {
  1697.                if(eval("\x01") == 23)
  1698.                {
  1699.                   set("\x01",eval("\x01") + 369);
  1700.                   play();
  1701.                   ┬º┬ºpush(┬º┬ºpop() eq ┬º┬ºpop());
  1702.                   break;
  1703.                }
  1704.                if(eval("\x01") == 335)
  1705.                {
  1706.                   set("\x01",eval("\x01") + 60);
  1707.                }
  1708.                else if(eval("\x01") == 159)
  1709.                {
  1710.                   set("\x01",eval("\x01") + 142);
  1711.                }
  1712.                else if(eval("\x01") == 416)
  1713.                {
  1714.                   set("\x01",eval("\x01") - 127);
  1715.                }
  1716.                else if(eval("\x01") == 289)
  1717.                {
  1718.                   set("\x01",eval("\x01") + 370);
  1719.                   ┬º┬ºpush(true);
  1720.                }
  1721.                else if(eval("\x01") == 490)
  1722.                {
  1723.                   set("\x01",eval("\x01") - 189);
  1724.                }
  1725.                else if(eval("\x01") == 183)
  1726.                {
  1727.                   set("\x01",eval("\x01") + 75);
  1728.                }
  1729.                else if(eval("\x01") == 347)
  1730.                {
  1731.                   set("\x01",eval("\x01") + 488);
  1732.                   if(┬º┬ºpop())
  1733.                   {
  1734.                      set("\x01",eval("\x01") - 264);
  1735.                   }
  1736.                }
  1737.                else if(eval("\x01") == 395)
  1738.                {
  1739.                   set("\x01",eval("\x01") - 48);
  1740.                   ┬º┬ºpush(true);
  1741.                }
  1742.                else
  1743.                {
  1744.                   if(eval("\x01") != 522)
  1745.                   {
  1746.                      if(eval("\x01") == 15)
  1747.                      {
  1748.                         set("\x01",eval("\x01") - 15);
  1749.                      }
  1750.                      break;
  1751.                   }
  1752.                   set("\x01",eval("\x01") - 502);
  1753.                }
  1754.             }
  1755.          }
  1756.          continue;
  1757.       }
  1758.       set("\x01",eval("\x01") - 338);
  1759.    }
  1760.    ┬º┬ºgoto(addr2785);
  1761. }
  1762.